Accelerated pattern matching method on a quantum computing system

ABSTRACT

A method of determining a pattern in a sequence of bits using a quantum computing system includes setting a first register of a quantum processor in a superposition of a plurality of string index states, encoding a bit string in a second register of the quantum processor, encoding a bit pattern in a third register of the quantum processor, circularly shifting qubits of the second register conditioned on the first register, amplifying an amplitude of a state combined with the first register in which the circularly shifted qubits of the second register matches qubits of the third register, measuring an amplitude of the first register and determining a string index state of the plurality of string index states associated with the amplified state, and outputting, by use of a classical computer, a string index associated with the first register in the measured state.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation application of U.S. patentapplication Ser. No. 17/313,671, filed May 6, 2021, which claims thebenefit to U.S. Provisional Application No. 63/031,385, filed May 28,2020, both of which are incorporated by reference herein.

GOVERNMENT LICENSE RIGHTS

This invention was made with Government support under DESC0019040 andDE-SC0020312 awarded by the Department of Energy. The Government hascertain rights in the invention.

BACKGROUND Field

The present disclosure generally relates to a method of performingcomputation in a quantum computing system, and more specifically, to amethod of searching for a bit pattern in a bit string using a computingsystem that are a group of trapped ions.

Description of the Related Art

In quantum computing, quantum bits or qubits, which are analogous tobits representing a “0” and a “1” in a classical (digital) computer, arerequired to be prepared, manipulated, and measured (read-out) with nearperfect control during a computation process.

Among physical systems upon which it is proposed to build large-scalequantum computers, is a group of ions (e.g., charged atoms), which aretrapped and suspended in vacuum by electromagnetic fields. The ions haveinternal hyperfine states which are separated by frequencies in theseveral GHz range and can be used as the computational states of a qubit(referred to as “qubit states”). These hyperfine states can becontrolled using radiation provided from a laser, or sometimes referredto herein as the interaction with laser beams. The ions can be cooled tonear their motional ground states using such laser interactions. Theions can also be optically pumped to one of the two hyperfine stateswith high accuracy (preparation of qubits), manipulated between the twohyperfine states (single-qubit gate operations) by laser beams, andtheir internal hyperfine states detected by fluorescence uponapplication of a resonant laser beam (read-out of qubits). A pair ofions can be controllably entangled (two-qubit gate operations) byqubit-state dependent force using laser pulses that couple the ions tothe collective motional modes of a group of trapped ions, which arisefrom their Coulombic interaction between the ions. In general,entanglement occurs when pairs or groups of ions (or particles) aregenerated, interact, or share spatial proximity in ways such that thequantum state of each ion cannot be described independently of thequantum state of the others, even when the ions are separated by a largedistance.

Pattern matching is ubiquitously used in various areas, such as imageprocessing, study of DNA sequences, and data compression and statistics.Computational complexity of a pattern matching process (i.e., the amountof resources required to run the pattern matching process, inparticular, time and memory requirements) varies as the size of inputvaries. For example, in a string matching process that is the simplestpattern matching process, in which a bit pattern

of length M is searched within a bit string

of length N (M≤N), the amount of time resources scales as Θ(N+M) inunits of elementary logic operations (which takes a constant amount oftime on a given computer) and the amount of memory resources scales as

(N+M) in units of bits, by the best known classical methods.

Therefore, there is a need for method for using a quantum processor tospeed up pattern matching in a quantum computing system.

SUMMARY

Embodiments described herein provide a method of determining a patternin a sequence of bits using a quantum computing system. The methodincludes setting a first register of a quantum processor in asuperposition of a plurality of string index states, encoding a bitstring in a second register of the quantum processor, encoding a bitpattern in a third register of the quantum processor, circularlyshifting qubits of the second register conditioned on the firstregister, amplifying an amplitude of a state combined with the firstregister in which the circularly shifted qubits of the second registermatches qubits of the third register, measuring an amplitude of thefirst register and determining a string index state of the plurality ofstring index states associated with the amplified state, and outputting,by use of a classical computer, a string index associated with the firstregister in the measured state.

Embodiments described herein also provides a quantum computing systemfor determining a pattern in a sequence of bits. The quantum computingsystem includes a quantum processor including a group of trapped ions,each of the trapped ions having two frequency-separated states, one ormore lasers configured to emit a laser beam, which is provided totrapped ions in the quantum processor, a classical computer, and asystem controller. The classical computer is configured to select a bitstring and a bit pattern to be searched within the bit string, each bitof the bit string having a string index. The system controller isconfigured to set a first register of the quantum processor in asuperposition of a plurality of string index states, each of which isassociated with a string index, encode the bit string in a secondregister of the quantum processor, encode the bit pattern in a thirdregister of the quantum processor, circularly shift qubits of the secondregister conditioned on the first register in each string index state inthe superposition of the plurality of string index states, amplify anamplitude of a state combined with the first register in a string indexstate of the plurality of string index states in which the circularlyshifted qubits of the second register matches qubits of the thirdregister, and measure an amplitude of the first register and determiningthe string index state of the plurality of string index statesassociated with the amplified state. The classical computer is furtherconfigured to output the string index associated with the first registerin the measured state.

Embodiments described herein further provide a quantum computing systemincluding non-volatile memory having a number of instructions storedtherein. The instruction, when executed by one or more processors, causethe quantum computing system to perform operations including setting afirst register of the quantum processor in a superposition of aplurality of string index states, each of which is associated with astring index, where the quantum processor includes a plurality ofqubits, encoding a bit string in a second register of the quantumprocessor, encoding a bit pattern in a third register of the quantumprocessor, circularly shifting qubits of the second register conditionedon the first register in each string index state in the superposition ofthe plurality of string index states, amplifying an amplitude of a statecombined with the first register in a string index state of theplurality of string index states in which the circularly shifted qubitsof the second register matches qubits of the third register, measuringan amplitude of the first register and determining the string indexstate of the plurality of string index states associated with theamplified state, and outputting, by use of a classical computer, thestring index associated with the first register in the measured state.The quantum computing system further includes selecting, by use of theclassical computer, the bit string and the bit pattern to be searchedwithin the bit string, each bit of the bit string having a string index,where each qubit of the plurality of qubits includes a trapped ionhaving two frequency-separated states. The quantum computing systemfurther includes preparing the quantum processor in an initial state bysetting, by a system controller, each trapped ion in the quantumprocessor in the lower energy state of the two frequency-separatedstates. Setting the first register of the quantum processor in thesuperposition of the plurality of string index states includestransferring, by the system controller, each trapped ion in the firstregister in a superposition of the two frequency-separated states.Encoding the bit string in the second register of the quantum processorincludes applying, by the system controller, a combination ofsingle-qubit gate operations to the second register of the quantumprocessor. Encoding the bit pattern in the third register of the quantumprocessor includes applying, by the system controller, a combination ofsingle-qubit gate operations to the third register of the quantumprocessor. Circularly shifting qubits of the second register conditionedon the first register includes applying, by the system controller, acombination of single-qubit gate operations and two-qubit gateoperations to the first and second registers of the quantum processor.The two-qubit gate operations includes controlled-SWAP operationsapplied to the second register conditioned on the first register. Thetwo-qubit gate operations includes controlled-SWAP operations applied tothe second register conditioned on a plurality of ancillary qubits inwhich the first register is copied by fan-out CNOT operations applied onthe plurality of ancillary qubits conditioned on the first register.Amplifying the state combined with the first register in the stringindex state of the plurality of string index states in which thecircularly shifted qubits of the second register matches qubits of thethird register includes applying, by the system controller, acombination of single-qubit gate operations and two-qubit gateoperations to the second and third registers of the quantum processor.

BRIEF DESCRIPTION OF THE DRAWINGS

So that the manner in which the above-recited features of the presentdisclosure can be understood in detail, a more particular description ofthe disclosure, briefly summarized above, may be had by reference toembodiments, some of which are illustrated in the appended drawings. Itis to be noted, however, that the appended drawings illustrate onlytypical embodiments of this disclosure and are therefore not to beconsidered limiting of its scope, for the disclosure may admit to otherequally effective embodiments.

FIG. 1 is a schematic partial view of an ion trap quantum computingsystem according to one embodiment.

FIG. 2 depicts a schematic view of an ion trap for confining ions in agroup according to one embodiment.

FIG. 3 depicts a schematic energy diagram of each ion in a group oftrapped ions according to one embodiment.

FIG. 4 depicts a qubit state of an ion represented as a point on asurface of the Bloch sphere.

FIGS. 5A, 5B, and 5C depict a few schematic collective transversemotional mode structures of a group of five trapped ions.

FIGS. 6A and 6B depict schematic views of motional sideband spectrum ofeach ion and a motional mode according to one embodiment.

FIG. 7 depicts a flowchart illustrating a method of searching for a bitpattern within a bit string according to one embodiment.

To facilitate understanding, identical reference numerals have beenused, where possible, to designate identical elements that are common tothe figures. In the figures and the following description, an orthogonalcoordinate system including an X-axis, a Y-axis, and a Z-axis is used.The directions represented by the arrows in the drawing are assumed tobe positive directions for convenience. It is contemplated that elementsdisclosed in some embodiments may be beneficially utilized on otherimplementations without specific recitation.

DETAILED DESCRIPTION

Embodiments described herein are generally related to a method ofperforming computation in a quantum computing system, and morespecifically, to a method of searching for a bit pattern in a bit stringusing a computing system that are a group of trapped ions.

A quantum computing system that is able to solve a pattern matchingproblem may include a classical computer, a system controller, and aquantum processor. The classical computer performs supporting and systemcontrol tasks including selecting a bit string and a bit pattern to besearched within the bit string by use of a user interface. The classicalcomputer further converts a series of logic gates into laser pulses tobe applied on the quantum processor by the system processor. A softwareprogram for performing the tasks is stored in a non-volatile memorywithin the classical computer. The quantum processor includes trappedions that are coupled by use of various hardware, including lasers tomanipulate internal hyperfine states (qubit states) of the trapped ionsand photomultiplier tubes (PMTs) to read-out the internal hyperfinestates (qubit states) of the trapped ions. The system controllerreceives from the classical computer instructions for controlling thequantum processor, and controls various hardware associated withcontrolling any and all aspects of the process of controlling thequantum processor, and returns a read-out of the quantum processor andthus output of results of the computation(s) to the classical computer.

The methods and systems described herein include an efficient patternmatching routine that provides improvements over conventional patternmatching routines.

General Hardware Configurations

FIG. 1 is a schematic partial view of an ion trap quantum computingsystem, or system 100, according to one embodiment. The system 100includes a classical (digital) computer 102, a system controller 104 anda quantum processor that is a group 106 of trapped ions (i.e., fiveshown) that extend along the Z-axis. Each ion in the group 106 oftrapped ions is an ion having a nuclear spin I and an electron spin Ssuch that a difference between the nuclear spin I and the electron spinS is zero, such as a positive ytterbium ion, ¹⁷¹Yb⁺, a positive bariumion ¹³³Ba⁺, a positive cadmium ion ¹¹¹cd⁺ or ¹¹³Cd⁺, which all have anuclear spin I=½ and the ²S_(1/2) hyperfine states. In some embodiments,all ions in the group 106 of trapped ions are the same species andisotope (e.g., ¹⁷¹Yb⁺.) In some other embodiments, the group 106 oftrapped ions includes one or more species or isotopes (e.g., some ionsare ¹⁷¹Yb⁺ and some other ions are ¹³³Ba⁺). In yet additionalembodiments, the group 106 of trapped ions may include various isotopesof the same species (e.g., different isotopes of Yb, different isotopesof Ba). The ions in the group 106 of trapped ions are individuallyaddressed with separate laser beams. The classical computer 102 includesa central processing unit (CPU), memory, and support circuits (or I/O).The memory is connected to the CPU, and may be one or more of a readilyavailable memory, such as a read-only memory (ROM), a random accessmemory (RAM), floppy disk, hard disk, or any other form of digitalstorage, local or remote. Software instructions, algorithms and data canbe coded and stored within the memory for instructing the CPU. Thesupport circuits (not shown) are also connected to the CPU forsupporting the processor in a conventional manner. The support circuitsmay include conventional cache, power supplies, clock circuits,input/output circuitry, subsystems, and the like.

An imaging objective 108, such as an objective lens with a numericalaperture (NA), for example, of 0.37, collects fluorescence along theY-axis from the ions and maps each ion onto a multi-channelphoto-multiplier tube (PMT) 110 for measurement of individual ions.Non-copropagating Raman laser beams from a laser 112, which are providedalong the X-axis, perform operations on the ions. A diffractive beamsplitter 114 creates an array of static Raman beams 116 that areindividually switched using a multi-channel acousto-optic modulator(AOM) 118 and is configured to selectively act on individual ions. Aglobal Raman laser beam 120 illuminates all ions at once. In someembodiments, individual Raman laser beams (not shown) each illuminateindividual ions. The system controller (also referred to as a “RFcontroller”) 104 controls the AOM 118 and thus controls laser pulses tobe applied to trapped ions in the group 106 of trapped ions. The systemcontroller 104 includes a central processing unit (CPU) 122, a read-onlymemory (ROM) 124, a random access memory (RAM) 126, a storage unit 128,and the like. The CPU 122 is a processor of the system controller 104.The ROM 124 stores various programs and the RAM 126 is the workingmemory for various programs and data. The storage unit 128 includes anonvolatile memory, such as a hard disk drive (HDD) or a flash memory,and stores various programs even if power is turned off. The CPU 122,the ROM 124, the RAM 126, and the storage unit 128 are interconnectedvia a bus 130. The system controller 104 executes a control programwhich is stored in the ROM 124 or the storage unit 128 and uses the RAM126 as a working area. The control program will include softwareapplications that include program code that may be executed by processorin order to perform various functionalities associated with receivingand analyzing data and controlling any and all aspects of the methodsand hardware used to create the ion trap quantum computer system 100discussed herein.

FIG. 2 depicts a schematic view of an ion trap 200 (also referred to asa Paul trap) for confining ions in the group 106 according to oneembodiment. The confining potential is exerted by both static (DC)voltage and radio frequency (RF) voltages. A static (DC) voltage V s isapplied to end-cap electrodes 210 and 212 to confine the ions along theZ-axis (also referred to as an “axial direction” or a “longitudinaldirection”). The ions in the group 106 are nearly evenly distributed inthe axial direction due to the Coulomb interaction between the ions. Insome embodiments, the ion trap 200 includes four hyperbolically-shapedelectrodes 202, 204, 206, and 208 extending along the Z-axis.

During operation, a sinusoidal voltage V₁ (with an amplitude V_(RF)/2)is applied to an opposing pair of the electrodes 202, 204 and asinusoidal voltage V₂ with a phase shift of 180° from the sinusoidalvoltage V₁ (and the amplitude V_(RF)/2) is applied to the other opposingpair of the electrodes 206, 208 at a driving frequency ω_(RF),generating a quadrupole potential. In some embodiments, a sinusoidalvoltage is only applied to one opposing pair of the electrodes 202, 204,and the other opposing pair 206, 208 is grounded. The quadrupolepotential creates an effective confining force in the X-Y planeperpendicular to the Z-axis (also referred to as a “radial direction” or“transverse direction”) for each of the trapped ions, which isproportional to a distance from a saddle point (i.e., a position in theaxial direction (Z-direction)) at which the RF electric field vanishes.The motion in the radial direction (i.e., direction in the X-Y plane) ofeach ion is approximated as a harmonic oscillation (referred to assecular motion) with a restoring force towards the saddle point in theradial direction and can be modeled by spring constants k_(x) and k_(y),respectively, as is discussed in greater detail below. In someembodiments, the spring constants in the radial direction are modeled asequal when the quadrupole potential is symmetric in the radialdirection. However, undesirably in some cases, the motion of the ions inthe radial direction may be distorted due to some asymmetry in thephysical trap configuration, a small DC patch potential due toinhomogeneity of a surface of the electrodes, or the like and due tothese and other external sources of distortion the ions may lieoff-center from the saddle points.

FIG. 3 depicts a schematic energy diagram 300 of each ion in the group106 of trapped ions according to one embodiment. Each ion in the group106 of trapped ions is an ion having a nuclear spin I and an electronspin S such that a difference between the nuclear spin I and theelectron spin S is zero. In one example, each ion may be a positiveYtterbium ion, ¹⁷¹Yb⁺, which has a nuclear spin I=½ and the ²S_(1/2)hyperfine states (i.e., two electronic states) with an energy splitcorresponding to a frequency difference (referred to as a “carrierfrequency”) of ω₀₁/2π=12.642821 GHz. In other examples, each ion may bea positive barium ion ¹³³Ba⁺, a positive cadmium ion ca or ¹¹³Cd⁺, whichall have a nuclear spin I=½ and the ²S_(1/2) hyperfine states. A qubitis formed with the two hyperfine states, denoted as |0

and |1

, where the hyperfine ground state (i.e., the lower energy state of the²S_(1/2) hyperfine states) is chosen to represent |0

. Hereinafter, the terms “hyperfine states,” “internal hyperfinestates,” and “qubits” may be interchangeably used to represent |0

and |1

. Each ion may be cooled (i.e., kinetic energy of the ion may bereduced) to near the motional ground state |0

_(m) for any motional mode m with no phonon excitation (i.e., n_(ph)=0)by known laser cooling methods, such as Doppler cooling or resolvedsideband cooling, and then the qubit state prepared in the hyperfineground state |0

by optical pumping. Here, |0

represents the individual qubit state of a trapped ion whereas |0

_(m) with the subscript m denotes the motional ground state for amotional mode m of a group 106 of trapped ions.

An individual qubit state of each trapped ion may be manipulated by, forexample, a mode-locked laser at 355 nanometers (nm) via the excited²P_(1/2) level (denoted as |e

). As shown in FIG. 3 , a laser beam from the laser may be split into apair of non-copropagating laser beams (a first laser beam with frequencyω₁ and a second laser beam with frequency ω₂) in the Ramanconfiguration, and detuned by a one-photon transition detuning frequencyΔ=ω₁−ω_(0e) with respect to the transition frequency ω_(0e) between |0

and |e

, as illustrated in FIG. 3 . A two-photon transition detuning frequencyδ includes adjusting the amount of energy that is provided to thetrapped ion by the first and second laser beams, which when combined isused to cause the trapped ion to transfer between the hyperfine states|0

and |1

. When the one-photon transition detuning frequency Δ is much largerthan a two-photon transition detuning frequency (also referred to simplyas “detuning frequency”) δ=ω₁−φ₂−ω₀₁ (hereinafter denoted as ±μ, μ beinga positive value), single-photon Rabi frequencies Ω_(0e)(t) andΩ_(1e)(t) (which are time-dependent, and are determined by amplitudesand phases of the first and second laser beams), at which Rabi floppingbetween states |0

and |e

and between states |1

and |e

respectively occur, and a spontaneous emission rate from the excitedstate |e

, Rabi flopping between the two hyperfine states |0

and |1

(referred to as a “carrier transition”) is induced at the two-photonRabi frequency Ω(t). The two-photon Rabi frequency Ω(t) has an intensity(i.e., absolute value of amplitude) that is proportional toΩ_(0e)Ω_(1e)/2Δ, where Ω_(0e) and Ω_(1e) are the single-photon Rabifrequencies due to the first and second laser beams, respectively.Hereinafter, this set of non-propagating laser beams in the Ramanconfiguration to manipulate internal hyperfine states of qubits (qubitstates) may be referred to as a “composite pulse” or simply as a“pulse,” and the resulting time-dependent pattern of the two-photon Rabifrequency Ω(t) may be referred to as an “amplitude” of a pulse or simplyas a “pulse,” which are illustrated and further described below. Thedetuning frequency δ=ω₁−ω₂−ω₀₁ may be referred to as detuning frequencyof the composite pulse or detuning frequency of the pulse. The amplitudeof the two-photon Rabi frequency Ω(t), which is determined by amplitudesof the first and second laser beams, may be referred to as an“amplitude” of the composite pulse.

It should be noted that the particular atomic species used in thediscussion provided herein is just one example of atomic species whichhave stable and well-defined two-level energy structures when ionizedand an excited state that is optically accessible, and thus is notintended to limit the possible configurations, specifications, or thelike of an ion trap quantum computer according to the presentdisclosure. For example, other ion species include alkaline earth metalions (Be⁺, Ca⁺, Sr⁺, Mg⁺, and Ba⁺) or transition metal ions (Zn⁺, Hg⁺,Cd⁺).

FIG. 4 is provided to help visualize a qubit state of an ion isrepresented as a point on a surface of the Bloch sphere 400 with anazimuthal angle ϕ and a polar angle θ. Application of the compositepulse as described above, causes Rabi flopping between the qubit state|0

(represented as the north pole of the Bloch sphere) and |1

(the south pole of the Bloch sphere) to occur. Adjusting time durationand amplitudes of the composite pulse flips the qubit state from |0

to |1

(i.e., from the north pole to the south pole of the Bloch sphere), orthe qubit state from |1

to |0

(i.e., from the south pole to the north pole of the Bloch sphere). Thisapplication of the composite pulse is referred to as a “π-pulse”.Further, by adjusting time duration and amplitudes of the compositepulse, the qubit state |0

may be transformed to a superposition state |0

+|1

, where the two qubit states |0

and |1

are added and equally-weighted in-phase (a normalization factor of thesuperposition state is omitted hereinafter for convenience) and thequbit state |1

to a superposition state |0

−|1

, where the two qubit states |0

and |1

are added equally-weighted but out of phase. This application of thecomposite pulse is referred to as a “π/2-pulse”. More generally, asuperposition of the two qubits states |0

and |1

that are added and equally-weighted is represented by a point that lieson the equator of the Bloch sphere. For example, the superpositionstates |0

±|1

correspond to points on the equator with the azimuthal angle ϕ beingzero and π, respectively. The superposition states that correspond topoints on the equator with the azimuthal angle ϕ are denoted as |0

+e^(iϕ)1

(e.g., |0

±i|1

for ϕ=±π/2). Transformation between two points on the equator (i.e., arotation about the Z-axis on the Bloch sphere) can be implemented byshifting phases of the composite pulse.

Entanglement Formation

FIGS. 5A, 5B, and 5C depict a few schematic structures of collectivetransverse motional modes (also referred to simply as “motional modestructures”) of a group 106 of five trapped ions, for example. Here, theconfining potential due to a static voltage V s applied to the end-capelectrodes 210 and 212 is weaker compared to the confining potential inthe radial direction. The collective motional modes of the group 106 oftrapped ions in the transverse direction are determined by the Coulombinteraction between the trapped ions combined with the confiningpotentials generated by the ion trap 200. The trapped ions undergocollective transversal motions (referred to as “collective transversemotional modes,” “collective motional modes,” or simply “motionalmodes”), where each mode has a distinct energy (or equivalently, afrequency) associated with it. A motional mode having the m-th lowestenergy is hereinafter referred to as |n_(ph)

_(m), where n_(ph) denotes the number of motional quanta (in units ofenergy excitation, referred to as phonons) in the motional mode, and thenumber of motional modes M in a given transverse direction is equal tothe number of trapped ions in the group 106. FIGS. 5A-5C schematicallyillustrates examples of different types of collective transversemotional modes that may be experienced by five trapped ions that arepositioned in a group 106. FIG. 5A is a schematic view of a commonmotional mode |n_(ph)

_(m) having the highest energy, where M is the number of motional modes.In the common motional mode |n

_(m), all ions oscillate in phase in the transverse direction. FIG. 5Bis a schematic view of a tilt motional mode |n_(ph)

_(m-1) which has the second highest energy. In the tilt motional mode,ions on opposite ends move out of phase in the transverse direction(i.e., in opposite directions). FIG. 5C is a schematic view of ahigher-order motional mode |n_(ph)

_(m-3) which has a lower energy than that of the tilt motional mode|n_(ph)

_(m-1), and in which the ions move in a more complicated mode pattern.

It should be noted that the particular configuration described above isjust one among several possible examples of a trap for confining ionsaccording to the present disclosure and does not limit the possibleconfigurations, specifications, or the like of traps according to thepresent disclosure. For example, the geometry of the electrodes is notlimited to the hyperbolic electrodes described above. In other examples,a trap that generates an effective electric field causing the motion ofthe ions in the radial direction as harmonic oscillations may be amulti-layer trap in which several electrode layers are stacked and an RFvoltage is applied to two diagonally opposite electrodes, or a surfacetrap in which all electrodes are located in a single plane on a chip.Furthermore, a trap may be divided into multiple segments, adjacentpairs of which may be linked by shuttling one or more ions, or coupledby photon interconnects. A trap may also be an array of individualtrapping regions arranged closely to each other on a micro-fabricatedion trap chip. In some embodiments, the quadrupole potential has aspatially varying DC component in addition to the RF component describedabove.

In an ion trap quantum computer, the motional modes may act as a databus to mediate entanglement between two qubits and this entanglement isused to perform an XX gate operation. That is, each of the two qubits isentangled with the motional modes, and then the entanglement istransferred to an entanglement between the two qubits by using motionalsideband excitations, as described below. FIGS. 6A and 6B schematicallydepict views of a motional sideband spectrum for an ion in the group 106in a motional mode |n_(ph)

_(M) having frequency ω_(m) according to one embodiment. As illustratedin FIG. 6B, when the detuning frequency of the composite pulse is zero(i.e., a frequency difference between the first and second laser beamsis tuned to the carrier frequency, δ=ω₁−ω₂−ω₀₁=0), simple Rabi floppingbetween the qubit states |0

and |1

(carrier transition) occurs. When the detuning frequency of thecomposite pulse is positive (i.e., the frequency difference between thefirst and second laser beams is tuned higher than the carrier frequency,δ=ω₁−ω₂−ω₀₁=μ>0, referred to as a blue sideband), Rabi flopping betweencombined qubit-motional states |0

|n_(ph)

_(m) and |1

|n_(ph)+1

_(m) occurs (i.e., a transition from the m-th motional mode withn-phonon excitations denoted by |n_(ph)

_(m) to the m-th motional mode with (n_(ph)+1)-phonon excitationsdenoted by |n_(ph)+1

_(m) occurs when the qubit state |0

flips to |1

). When the detuning frequency of the composite pulse is negative (i.e.,the frequency difference between the first and second laser beams istuned lower than the carrier frequency by the frequency ω_(m) of themotional mode |n_(ph)

_(m), δ=ω₁−ω₂−ω₀₁=−μ<0, referred to as a red sideband), Rabi floppingbetween combined qubit-motional states |0

|n_(ph)

_(m) and |1

|n_(ph)−1

_(m) occurs (i.e., a transition from the motional mode |n_(ph)

_(m) to the motional mode |n_(ph)−1

_(m) with one less phonon excitations occurs when the qubit state |0

flips to |1

). A π/2-pulse on the blue sideband applied to a qubit transforms thecombined qubit-motional state |0

|n_(ph)

_(m) into a superposition of |0

|n_(ph)

_(m) and |1

|n_(ph)+1

_(m). A π/2-pulse on the red sideband applied to a qubit transforms thecombined qubit-motional |0

|n_(ph)

_(m) into a superposition of |0

|n_(ph)

_(m) and |1

|n_(ph)−1

_(m). When the two-photon Rabi frequency Ω(t) is smaller as compared tothe detuning frequency δ=ω₁−ω₂−ω₀₁=±μ, the blue sideband transition orthe red sideband transition may be selectively driven. Thus, a qubit canbe entangled with a desired motional mode by applying the right type ofpulse, such as a π/2-pulse, which can be subsequently entangled withanother qubit, leading to an entanglement between the two qubits that isneeded to perform an XX-gate operation in an ion trap quantum computer.

By controlling and/or directing transformations of the combinedqubit-motional states as described above, an XX-gate operation may beperformed on two qubits (i-th and j-th qubits). In general, the XX-gateoperation (with maximal entanglement) respectively transforms two-qubitstates |0

_(i)|0

_(j), |0

_(i)|1

_(j), |1

_(i)|0

_(j), and |1

_(i)|1

_(j)as follows:

-   -   |0        _(i)|0        _(j)→|0        _(i)|0        _(j)−i|1        _(i)|1        _(j)    -   |0        _(i)|1        _(j)→|0        _(i)|1        _(j)−i|1        _(i)|0        _(j)    -   |1        _(i)|0        _(j)→−i|0        _(i)|1        _(j)+|1        _(i)|0        _(j)    -   |1        _(i)|1        _(j)→−i|0        _(i)|0        _(j)+|1        _(i)|1        _(j)        For example, when the two qubits (i-th and j-th qubits) are both        initially in the hyperfine ground state |0        (denoted as |0        _(i)|0        _(j)) and subsequently a π/2-pulse on the blue sideband is        applied to the i-th qubit, the combined state of the i-th qubit        and the motional mode |0        _(i)|n_(ph)        _(m) is transformed into a superposition of |0        _(i)|n_(ph)        _(m) and |1        _(i)|n_(ph)+1        _(m), and thus the combined state of the two qubits and the        motional mode is transformed into a superposition of |0        _(i)|0        _(j)|n_(ph)        _(m) and |1        _(i)|0        _(j)|n_(ph)+1        _(m). When a π/2-pulse on the red sideband is applied to the        j-th qubit, the combined state of the j-th qubit and the        motional mode |0        _(j)|n_(ph)        _(m) is transformed to a superposition of |0        _(j)|n_(ph)        _(m) and |1        _(j)|n_(ph)−1        _(m) and the combined state |0        _(j)|n_(ph)+1        _(m) is transformed into a superposition of |0        _(j)|n_(ph)+1        _(m) and |1        _(j)|n_(ph)        _(m).

Thus, applications of a π/2-pulse on the blue sideband on the i-th qubitand a π/2-pulse on the red sideband on the j-th qubit may transform thecombined state of the two qubits and the motional mode |0

_(i)|0

_(j)|n_(ph)

_(m) into a superposition of |0

_(i)|0

_(j)|n_(ph)

_(m) and |1

_(i)|1

_(j)|n_(ph)

_(m), the two qubits now being in an entangled state. For those ofordinary skill in the art, it should be clear that two-qubit states thatare entangled with motional mode having a different number of phononexcitations from the initial number of phonon excitations n_(ph) (i.e.,|1

_(i)|0

_(j)|n_(ph)+1

_(m) and |0

_(i)|1

_(j)|n_(ph)−1

_(m)) can be removed by a sufficiently complex pulse sequence, and thusthe combined state of the two qubits and the motional mode after theXX-gate operation may be considered disentangled as the initial numberof phonon excitations n_(ph) in the m-th motional mode stays unchangedat the end of the XX-gate operation. Thus, qubit states before and afterthe XX-gate operation will be described below generally withoutincluding the motional modes.

More generally, the combined state of i-th and j-th qubits transformedby the application of pulses on the sidebands for duration T (referredto as a “gate duration”), having amplitudes Ω^((i)) and Ω^((i)) anddetuning frequency μ, can be described in terms of an entanglinginteraction x^((i,j))(t) as follows:

-   -   |0        _(i)|0        _(j)→cos (2x^((i,j))(t))|0        _(i)|0        _(j)−i sin (2x^((i,j))(t))|1        _(i)|1        _(j)    -   |0        _(i)|1        _(j)→cos (2x^((i,j))(t))|0        _(i)|1        _(j)−i sin (2x^((i,j))(t))|1        _(i)|0        _(j)    -   |1        _(i)|0        _(j)→−i sin (2x^((i,j))(t))|0        _(i)|1        _(n,j)+cos (2X^((i,j))(t))|1        _(i)|0        _(j)    -   |1        _(i)|1        _(j)→−i sin (2X^((i,j))(t))|0        _(i)|0        _(j)+cos (2X^((i,j))(t))|1        _(i)|1        _(j)        where,

${\chi^{({i,j})}(\tau)} = {{- 4}{\sum\limits_{m = 1}^{M}{\eta_{m}^{(i)}\eta_{m}^{(j)}{\int\limits_{0}^{\tau}{{dt}_{2}{\int\limits_{0}^{t_{2}}{{dt}_{1}{\Omega^{(i)}\left( t_{2} \right)}{\Omega^{(j)}\left( t_{1} \right)}{\cos\left( {\mu t_{2}} \right)}{\cos\left( {\mu t_{1}} \right)}{\sin\left\lbrack {\omega_{m}\left( {t_{2} - t_{1}} \right)} \right\rbrack}}}}}}}}$

and n_(m) ^((i)) is the Lamb-Dicke parameter that quantifies thecoupling strength between the i-th ion and the m-th motional mode havingthe frequency W_(m), and M is the number of the motional modes (equal tothe number N of ions in the group 106).

The entanglement interaction between two qubits described above can beused to perform an XX-gate operation. The XX-gate operation (X(gate)along with single-qubit operations (R gates) forms a set of elementarylogic operations {R,XX} that can be used to build a quantum computerthat is configured to perform desired computational processes. Amongseveral known sets of elementary logic operations by which any quantumalgorithm can be decomposed, a set of elementary logic operations,commonly denoted as {R, XX}, is native to a quantum computing system oftrapped ions described herein. Here, the R gate corresponds tomanipulation of individual qubit states of trapped ions, and the XX gate(also referred to as an “entangling gate”) corresponds to manipulationof the entanglement of two trapped ions.

To perform an XX-gate operation between i-th and j-th qubits, pulsesthat satisfy the condition x^((i,j))(t)=θ^((i,j))(0<θ^((i,j))≤π/8)(i.e., the entangling interaction x^((i,j))(t) has a desired value OM,referred to as condition for a non-zero entanglement interaction) areconstructed and applied to the i-th and the j-th qubits. Thetransformations of the combined state of the i-th and the j-th qubitsdescribed above corresponds to the XX-gate operation with maximalentanglement when θ^((i,j))=π/8. Amplitudes Ω^((i))(t) and Ω^((i))(t) ofthe pulses to be applied to the i-th and the j-th qubits are controlparameters that can be adjusted to ensure a non-zero tunableentanglement of the i-th and the j-th qubits to perform a desired XXgate operation on i-th and j-th qubits.

Other two-qubit gate operations, such as a controlled-NOT (referred toas “CNOT”) gate and a SWAP gate, may be used in the method of patternmatching described below and implemented by use of a combination of theXX gate operations and single-qubit gate operations.

In general, a CNOT gate operation conditioned on i-th qubit (controlbit) and targeted on j-th qubit (target bit) inverts the j-th qubit(target bit) if the i-th qubit (control bit) in state |1

, and leaves both the i-th and j-th qubits unchanged otherwise, thustransforming a two-qubit state |x

_(i)|y

_(j)(x,y={0,1}) to a two-qubit state |x

_(i)|x⊕y

:

$\left. {\left. {\left. {\left. {❘x} \right\rangle_{i}{❘y}} \right\rangle_{j}\overset{CNOT}{\rightarrow}{❘x}} \right\rangle_{i}{❘{x \oplus y}}} \right\rangle_{j}.$

The output of the j-th qubit (target bit) is the exclusive OR (XOR,denoted by “⊕”) of the i-th and j-th qubits. A SWAP gate operationbetween i-th and j-th qubits swaps the i-th and j-th qubits, thustransforming a two-qubit state |x

_(i)|y

_(j)(x,y={1,1}) to a two-qubit state

$\left. {\left. {\left. {\left. {\left. {\left. {❘y} \right\rangle_{i}{❘x}} \right\rangle_{j}:{❘x}} \right\rangle_{i}{❘y}} \right\rangle_{j}\overset{SWAP}{\rightarrow}{❘y}} \right\rangle_{i}{❘x}} \right\rangle_{j}.$

Three-qubit gate operations, such as a controlled-controlled-NOT gate(also referred to as “Toffoli gate”) and a controlled-SWAP gate (alsoreferred to as “Fredkin gate”), may also be used in the method ofpattern matching described below and implemented by use of a combinationof the XX gate operations and single-qubit gate operations. A Toffoligate operation applied to two control bits and one target bit invertsthe target bit only if both of the control bits are in state II), andleaves all three qubits unchanged otherwise, thus transforming athree-qubit state |x

|y

|z

(x,y,z={0,1}) to a three-qubit state |x

|y

|(x y)⊕z):

$\left. {\left. {\left. {\left. {\left. {\left. {❘x} \right\rangle{❘y}} \right\rangle{❘z}} \right\rangle\overset{Toffoli}{\rightarrow}{❘x}} \right\rangle{❘y}} \right\rangle{❘{\left( {x \cdot y} \right) \oplus z}}} \right\rangle.$

The output of the target bit includes XOR (⊕) of the target bit and AND(denoted by “·”) of the control qubits. A Fredkin gate operation appliedto one control bit and two target bits swaps the target bits if thecontrol bit is state |1

, and laves all three qubits unchanged otherwise, thus transforming athree-qubit state |x

|y

|z

(x,y,z={0,1}) to a three-qubit state |x

|(x·Z)⊕(x·Y))|(X·Y)⊕(x·Z)):

$\left. {\left. {\left. {\left. {\left. {\left. {❘x} \right\rangle{❘y}} \right\rangle{❘z}} \right\rangle\overset{Fredkin}{\rightarrow}{❘x}} \right\rangle{❘{\left( {x \cdot z} \right) \oplus \left( {\overset{\_}{x} \cdot y} \right)}}} \right\rangle{❘{\left( {x \cdot y} \right) \oplus \left( {\overset{\_}{x} \cdot z} \right)}}} \right\rangle,$

where the output of the target bits include NOT of the target bit(denoted by “−”).

Accelerated Pattern Matching Method on a Quantum Computing System

In a quantum computing system, a quantum computer is a domain-specificaccelerator (also referred to as a “quantum processor” hereinafter) thatis able to accelerate certain computational tasks beyond the reach ofclassical computers. Examples of such computational tasks includesearching a given set of data that can be used for pattern matching.Pattern matching is used in a wide range of applications, such imageprocessing, study of DNA sequences, and data compression and statistics.However, complexity of pattern matching increases drastically as aproblem size (e.g., the lengths of a string and a pattern to be searchedwithin the string) increases and may be unsolvable or be too complex tocomplete in a reasonable amount of time by a classical computer alone.Thus, methods for accelerated pattern matching on a quantum computingsystem are described herein.

It should be noted that the particular example embodiments describedherein are just some possible examples of a quantum computing systemaccording to the present disclosure and do not limit the possibleconfigurations, specifications, or the like of quantum computer systemsaccording to the present disclosure. For example, a quantum computingsystem according to the present disclosure can be applied to other typesof computational task in which searching of data contributes to thecomputational complexity and can be accelerated by use of a quantumprocessor.

FIG. 7 depicts a flowchart illustrating a method 700 of searching for abit pattern within a bit string. A bit string and a bit pattern aresequences of bits, each of which has single binary value, either 0 or 1.In the example described herein, the quantum processor is the group 106of trapped ions, in which the two hyperfine states of each of thetrapped ions form a qubit that has binary qubit states |0

and |1

.

In block 702, by the classical computer 102, a pattern matching problemis selected, for example, by use of a user interface of the classicalcomputer 102, or retrieved from the memory of the classical computer102. Specifically, a bit string

(t₀t₁, . . . t_(N−1)) of length N and a bit pattern

(p₀p₁ . . . P_(M−1)) of length M with M≤N are selected. The patternmatching problem is to search and locate the bit pattern

within the bit string

. Pattern matching may be exact match (i.e., a M-bit long sequencecontained in the bit string

exactly matches the bit pattern

) or fuzzy match (i.e., (M−d) bits of a M-bit long sequence contained inthe bit string

matches the bit pattern

, where d is a predetermined number indicating fuzziness in thematching).

In block 704, by the system controller 104, the quantum processor 106 isset in an initial state |Ψ₀

=|0

_(I)|0

_(T)|0

_(P). The first register (denoted by the subscript “I” and referred toalso as an “index register” hereinafter) is formed of n=log₂/N qubits|k₀

|k₁

. . . |k_(n−1)

=⊗_(i=0) ^(n−1)|k_(i)

to be used to encode a string index k(=2⁰k₀+2¹k₁+ . . .+2^(n−1)k_(n−1)=E₁₌₀ ^(n−1)2^(j)K_(j)=0,1, . . . ,N−1). In the initialstate |Ψ₀

=|0

_(I)|0

_(T)|0

_(p), all qubits of the index register are prepared in state |0

(i.e., |0

_(I)=|0

^(⊗n)), for example, the hyperfine ground state |0

, by optical pumping in an exemplary quantum computer with trapped ions.The second register (denoted by the subscript “T” and referred to alsoas a “string register” hereinafter) is formed of N qubits to be used toencode the bit string

(t₀t₁ . . . t_(N−1)). In the initial state |Ψ₀

=|0

_(I)|0

_(T)|0

_(p), all qubits of the string register are prepared in state |0

(i.e., |0

_(T)=|0

^(⊗N)). The third register (denoted by the subscript “P” and referred toas a “pattern register” hereinafter) is formed of M qubits to be used toencode the bit pattern

. In the initial state |Ψ₀

=|0

_(I)|0

_(T)|0

_(p), all qubits of the pattern register are prepared in state |0

(i.e., |0

_(p)=|0

^(εM)).

In block 706, by the system controller 104, each qubit of the indexregister is transformed from state |0

to a linear superposition state of |0

and |1

, (|0

+|1

)/√{square root over (2)}, thus transforming the index register from theinitial state |0

_(I)=|0

on to a superposition state

$\left( \frac{\left. {\left. {❘0} \right\rangle + {❘1}} \right\rangle}{\sqrt{2}} \right)^{\otimes n} = {\otimes_{j = 0}^{n - 1}\left( {{\sum}_{k_{j} = {\{{0,1}\}}}\frac{\left. {❘k_{j}} \right\rangle}{\sqrt{2}}} \right)}$

in the quantum processor 106. The index register is now in asuperposition of 2^(n)(=N) states (|0

|0

. . . |0

,|0

|0

. . . |1

, . . . , |1

|1

. . . |1

) each associated with a string index k(=0, 1, . . . , N−1) (thus,referred to as string index states), and may be denoted as

$\left. {\frac{1}{\sqrt{N}}{\sum}_{k = 0}^{N - 1}{❘k}} \right\rangle_{I},$

where |k

_(I) is a stale formed of n (=log₂N) qubits defined as |k

_(I)=|k₀

|k₁

. . . |k_(n−1)

(k=Σ_(j=0) ^(n−1)2^(j)k_(j)=_(0,1), . . . , N−1). By thistransformation, the quantum processor 106 is transformed from theinitial state |Ψ0

=|0

_(I)|0

_(T)|0

_(p) to an initial superposition state

$\left. {\left. {\left. {\left. {❘\psi_{S}} \right\rangle = {\frac{1}{\sqrt{N}}{\sum}_{k = 0}^{N - 1}{❘k}}} \right\rangle_{I}{❘0}} \right\rangle_{T}{❘0}} \right\rangle_{P}$

(i.e., a superposition of combined states of the index register, thestring register, and the pattern register). This transformation may beimplemented by application of a proper combination of single-qubitoperations to the n=(log₂N) qubits of the index register in the initialstate |Ψ₀

=|0

_(I)|0

_(T)|0

_(p) in a single time step in units of elementary logic operations.

In block 708, by the system controller 104, the bit string

(t₀t₁ . . . t_(N−1)) is encoded in the string register, and the bitpattern

(p₀p₁ . . . p_(M−1)) is encoded in the pattern register in the quantumprocessor 106. Specifically, the i-th bit information t_(i)(i=0,1, . . .N−1) of the bit string

(t₀t₁ . . . t_(N−1)) is encoded in the i-th qubit of the string registeras |

_(T)=|t₀

|t₁

. . . |t_(N−1)

=⊗_(i=0) ^(N−1)|t_(i)

(i=0,1, . . . N−1) (referred to as a string encoded state). That is, thestring register is transformed form the initial state of the stringregister |0

_(T) to the string encoded state |

_(T). Similarly, the i-th bit information p_(i)(i=0,1, . . . M−1) of thebit pattern

(p₀p₁ . . . P_(M)) is encoded in the i-th qubit of the pattern registeras |

_(p)=|p₀

|p₁

. . . |p_(M−1)

=⊗_(i=0) ^(M−1)|p_(i)

(i=0, 1, . . . M−1) (referred to as a pattern encoded state). That is,the pattern register is transformed from the initial state of thepattern register |0

_(p) to the pattern encoded state β

_(p). These operations may be implemented by application of a propercombination of single-qubit operations to the N qubits of the stringregister in the initial state |0

_(T) and to the M qubits of the pattern register in the initial state |0

_(p) in a single time step in units of elementary logic operations.

In block 710, by the system controller 104, a controlled-circular-shiftoperation S is applied on the string register in the string encodedstate |

_(T)=⊗_(i=0) ^(N−1)|t_(i)

conditioned on the index register in the initial superposition state

$\left. {\frac{1}{\sqrt{N}}{\sum}_{k = 0}^{N - 1}{❘k}} \right\rangle_{I}$

in the quantum processor 106. That is, all qubits of the string registerare circularly shifted (e.g., left-circularly shifted) by k bitpositions in a combined state having the index register in state |k

_(I) (referred to as an operation S_(k)):

[|k

_(I)⊗_(i=0) ^(M−1) |t _(i)

]=|k

_(I)⊗_(i=0) ^(N−1)

_(k) |t _(i)

=|k

_(I)⊗_(i=0) ^(N−1) |t _(i+k mod N)

.

Thus, the operation S_(k) transforms the string register in the statehaving the index register in |k

_(I) from the string encoded state |

_(T)=⊗_(i=0) ^(N−1)|t_(i)

to a circularly shifted state |

_(T) ^((k))=⊗_(i=0) ^(N−1)|t_(i+k mod N)

.

The controlled-circular-shift operation S_(k) conditioned on the n-qubitlong index register |k

_(I) may be implemented as a series of bit-wise circular shift operation

_(2j) ^((k)) conditioned on the j-th qubit |k_(i)

of the index register that left-circularly shifts all qubits of thestring register by 2^(j) bit positions: |k

_(I)⊗_(i=0) ^(N−1)

_(k)|t_(i)

=(⊗_(j=0) ^(n−1)|k_(j)

)⊗_(i=0) ^(N−1)(Π_(j=0) ^(n−1)

_(2j) ^((kj)))|t_(i)

.

The bit-wise controlled-circular-shift operator S_(2j) ^((kj)) may beimplemented as a combination of controlled-SWAP operations targeted onthe string register (each of which interchanges a pair among the Nqubits of the string register) conditioned on the j-th qubit |k_(j)

of the index register. Among the required controlled-SWAP operations,N/2 controlled-SWAP operations to circularly shift N/2 qubits among thetotal N qubits by 2^(j) bit positions may be applied in a single timestep in units of elementary logic operations as described in detailbelow. In a subsequent time step, N/4 controlled-SWAP operations areapplied to circularly shift a half of the N/2 remaining qubits by 2^(j)bit positions. At each subsequent time step, the number of qubits thatneed to be swapped decreased by half. Therefore, the bit-wisecontrolled-circular-shift operator

_(2j) ^((kj)) targeted on N qubits may be implemented in

(log(N)) time steps in units of elementary logic operations usingparallel controlled-SWAP operations.

To implement, in one time step in units of elementary logic operations,at most N/2 controlled-SWAP operations controlled by the same controlqubit, N/2 ancillary qubits, each initialized to state |0

, may be used. Using a fan-out CNOT operation on the ancillary qubitswith the control qubit, the control qubit state may be copied into theancillary qubits. With the N/2 available copies of the control qubitstate, each controlled-SWAP operations may then be implemented inparallel since each one of at most N/2 controlled-SWAP operations mayuse each one of the available control state copies encoded in theancillary qubits. Once all of controlled-SWAP operations in a givenbit-wise i) controlled-circular-shift operator

_(2j) ^((kj)) are implemented, the ancillary qubits may be restored tostate |0

by subsequently applying another fan-out CNOT operation as describedabove. The fan-out operation may be implemented in

(log(N)) time steps in units of elementary logic operations.

The CNOT gate operations and the controlled-SWAP operations used toperform the controlled-circular-shift operation

may be each implemented by application of a proper combination ofsingle-qubit operations and two-qubit gate operations to the n=(log₂N)qubits of the index register in the initial superposition state

$\left. {\frac{1}{\sqrt{N}}{\sum}_{k = 0}^{N - 1}{❘k}} \right\rangle_{I},$

the N qubits of the string register in the string encoded state |

_(T)=⊗_(i=0) ^(N−1)|t_(i)

, and N/2 ancillary qubits, each initialized to state |0

.

In block 712, by the system controller 104, a bit-wise CNOT gateoperation is applied on the pattern register in the pattern encodedstate |

_(p)=⊗_(i=0) ^(M−1)|p_(i)

conditioned on the first M bits of the string register in the stringencoded state |

_(T) ^((k))=⊗_(i=0) ^(N−1)|t_(i+k mod N)

. That is, the bit-wise CNOT gate operation brings the pattern registerfrom the pattern encoded state |

_(p)=⊗_(i=0) ^(M−1)|p_(i)

to a string-pattern matching evaluation state (⊗_(i=0)^(M−1)|p_(i)⊗t_(i+k mod N)

) After this transformation, if the first M bits of the string registerin the circularly shifted state |

_(T) ^((k))=⊗_(i=0) ^(N−1)|t_(i+k mod N))exactly match all qubits of thepattern register in the pattern encoded state |

_(p)=⊗_(i=0) ^(M−1)|p_(i)

(i.e., exact matching), all qubits |p_(i)⊗t_(i+k mod N)

of the pattern register in the string-pattern matching evaluation state(⊗_(i=0) ^(M−1)|p_(i)⊗t_(i+k mod N)

) are in state |0

. If the first M qubits except for d qubits of the string register inthe circularly shifted state |

_(T) ^((k))=⊗_(i=0) ^(N−1)|t_(i+k mod N)

match the qubits of the pattern register in the pattern encoded state |

_(p)=⊗_(i=0) ^(M−1)|p_(i)

(i.e., fuzzy matching), (M−d) qubits |p_(i)⊗t_(i+k mod N)) of thepattern register in the string-pattern matching evaluation state(⊗_(i=0) ^(M−1)|p_(i)⊗t_(i+k mod N)

) are in state |0

and d bits are in state |1

.

The bit-wise CNOT gate operations can be implemented by the applicationof a combination of single-qubit gate operations and two-qubit gateoperations by the system controller 104 in a single time step in unitsof elementary logic operations.

In block 714, by the system controller 104, the string-pattern matchingevaluation state (⊗_(i=0) ^(M−1)|p_(i)⊗t_(i+k mod N)

) having (M−d) or more qubits in state |0

(referred to as a matched state) is amplified and measured. The exactmatching corresponds to d=0. The fuzzy matching corresponds to d≥0. Thestring index k specifies the location of the matched string. Theamplification of the matched state may be performed by applying anoracle operation U W on the pattern register, which reverses a phase ofthe matched state:

$\left. {\otimes_{i = 0}^{M - 1}{❘x_{i}}} \right\rangle\overset{U_{w}}{\rightarrow}\left\{ {\begin{matrix}\left. {\left( {- 1} \right) \otimes_{i = 0}^{M - 1}{❘x_{i}}} \right\rangle & {{{if}{\sum\limits_{i = 0}^{M - 1}x_{i}}} \leq d} \\\left. {\left( {+ 1} \right) \otimes_{i = 0}^{M - 1}{❘x_{i}}} \right\rangle & {{{if}{\sum\limits_{i = 0}^{M - 1}x_{i}}} \geq d}\end{matrix}.} \right.$

Oracle operations, such as the oracle operation U_(W) described herein,may be implemented in

(log(M)) time steps in units of elementary logic operations using

(M) ancillary qubits in a quantum processor that has a long-rangeinteractions, such as the exemplary quantum computer with trapped ionsand needs to be repeated

(√{square root over (N)}) times for successful amplification. Once anamplitude of the index register (in the superposition of string indexstates) is measured, the matched state in which the string-patternmatching evaluation state (⊗_(i=0) ^(M−1)|p_(i)⊗t_(i+k mod N)

) having (M−d) or more qubits in state |0

has the largest amplitude. The string index k associated with themeasured matched state corresponds to the location of the pattern

within the bit string

. Subsequently, the classical computer 102 generally outputs themeasured result including whether or not the bit string

contains the bit pattern

and if it does, the location of the pattern

within the bit string

.

In the embodiments described herein, the methods for a more efficientand accelerated pattern matching process is provided. The amount of timeresources required to run a matching process for searching a bit pattern

of length M within a bit string

of length N by the method described herein scales as

(√{square root over (N)}(log(N)²+log(M))) time steps in units ofelementary logic operations. As described above, transformation of theindex register to the superposition state in block 706 and encoding ofthe bit string T and the pattern

in block 708 may be each implemented in a single time step in units ofelementary logic operations. In block 710, each bit-wisecontrolled-circular-shift operator

_(2j) ^((kj)) may be implemented in

(log(N)) time steps in units of elementary logic operations, and thusthe total controlled-circular-shift operation

(that is n=(log₂N) of the bit-wise controlled-circular shift operations)may be implemented in

(log(N)²) time steps in units of elementary logic operations. Theapplication of bit-wise CNOT gate operation in block 712 may beimplemented in a single time step in units of elementary logicoperations. The evaluation of matching of the bit string

and the pattern

using the oracle operation U_(W) in block 708 may be implemented in

(log(M)) time steps in units of elementary logic operations. Foramplitude amplification, this process is effectively repeated

(√{square root over (N)}) times. Thus, in total, the pattern matching bythe method described herein may be performed in

(√{square root over (N)}(log(N)²+log(M))) time steps in units ofelementary logic operations.

The amount of memory resources required to run a matching process forsearching a bit pattern

of length M within a bit string

of length N by the method described herein scales as

(N+M) qubits. As described above, the amount of memory resourcesincludes N to encode the bit string

(t₀t₁ . . . t_(N−1)) of length N, M to encode the bit pattern

(p₀p₁ . . . P_(M−1)) of length M, n=log₂N to encode the string index,N/2 of ancillary qubits to implement parallel controlled-SWAPoperations, and

(M) of ancillary qubits to implement the oracle operation U_(w). Thus,the method requires

(N+M) qubits in total. Therefore, the method described herein providesimprovement in the amount of time required to run a matching process byuse of a quantum processor over a purely classical computational method,by allowing simultaneous search of a bit pattern in multiple locationsin a bit string due to the use of the multiple states created by aquantum superposition.

While the foregoing is directed to specific embodiments, other andfurther embodiments may be devised without departing from the basicscope thereof, and the scope thereof is determined by the claims thatfollow.

1. A method of determining a pattern in a sequence of bits using aquantum computing system comprising a classical computer and a quantumprocessor comprising a plurality of qubits, the method comprising:circularly shifting qubits of a second register conditioned on a firstregister in each string index state in a superposition of a plurality ofstring index states, each of which is associated with a string index;amplifying an amplitude of a state combined with the first register in astring index state of the plurality of string index states in which thecircularly shifted qubits of the second register matches qubits of athird register; and measuring an amplitude of the first register anddetermining the string index state of the plurality of string indexstates associated with the amplified state.
 2. The method according toclaim 1, further comprising: prior to the circularly shifting of thequbits of the second register, setting the first register of the quantumprocessor in the superposition of the plurality of string index states;encoding a bit string in the second register of the quantum processor;and encoding a bit pattern in the third register of the quantumprocessor, and subsequent to the measuring of the amplitude of the firstregister, outputting, by use of the classical computer, the string indexassociated with the first register in the measured state.
 3. The methodaccording to claim 2, wherein encoding the bit string in the secondregister of the quantum processor comprises applying a combination ofsingle-qubit gate operations to the second register of the quantumprocessor.
 4. The method according to claim 2, wherein encoding the bitpattern in the third register of the quantum processor comprisesapplying a combination of single-qubit gate operations to the thirdregister of the quantum processor.
 5. The method according to claim 1,wherein each qubit of the plurality of qubits comprises a trapped ionhaving two frequency-separated states.
 6. The method according to claim5, further comprising: preparing the quantum processor in an initialstate by setting each trapped ion in the quantum processor in the lowerenergy state of the two frequency-separated states.
 7. The methodaccording to claim 6, wherein setting the first register of the quantumprocessor in the superposition of the plurality of string index statescomprises transferring each trapped ion in the first register in asuperposition of the two frequency-separated states.
 8. The methodaccording to claim 6, wherein circularly shifting qubits of the secondregister conditioned on the first register comprises applying acombination of single-qubit gate operations and two-qubit gateoperations to the first and second registers of the quantum processor.9. The method according to claim 8, wherein the two-qubit gateoperations comprise controlled-SWAP operations applied to the secondregister conditioned on the first register.
 10. The method according toclaim 8, wherein the two-qubit gate operations comprise controlled-SWAPoperations applied to the second register conditioned on a plurality ofancillary qubits in which the first register is copied by fan-out CNOToperations applied on the plurality of ancillary qubits conditioned onthe first register.
 11. The method according to claim 5, whereinamplifying the state combined with the first register in the stringindex state of the plurality of string index states in which thecircularly shifted qubits of the second register matches qubits of thethird register comprises applying a combination of single-qubit gateoperations and two-qubit gate operations to the second and thirdregisters of the quantum processor.
 12. A quantum computing system,comprising: a quantum processor comprising a plurality of qubits, eachqubit of the plurality of qubits comprising a trapped ion having twofrequency-separated states; one or more lasers configured to emit alaser beam, which is provided to trapped ions in the quantum processor;a classical computer; and a system controller configured to: circularlyshift qubits of a second register conditioned on a first register ineach string index state in a superposition of a plurality of stringindex states, each of which is associated with a string index; amplifyan amplitude of a state combined with the first register in a stringindex state of the plurality of string index states in which thecircularly shifted qubits of the second register matches qubits of athird register; and measure an amplitude of the first register anddetermining the string index state of the plurality of string indexstates associated with the amplified state.
 13. The quantum computingsystem according to claim 12, wherein the system controller is furtherconfigured to: prior to the circularly shifting of the qubits of thesecond register, set a first register of the quantum processor in asuperposition of a plurality of string index states, each of which isassociated with a string index, wherein the quantum processor comprisesa plurality of qubits; encode a bit string in a second register of thequantum processor; and encode a bit pattern in the third register of thequantum processor, and the classical computer is further configured to:subsequent to the measuring of the amplitude of the first register,output the string index associated with the first register in themeasured state.
 14. The quantum computing system according to claim 13,wherein encoding the bit string in the second register of the quantumprocessor comprises applying a combination of single-qubit gateoperations to the second register of the quantum processor, and encodingthe bit pattern in the third register of the quantum processor comprisesapplying a combination of single-qubit gate operations to the thirdregister of the quantum processor.
 15. The quantum computing systemaccording to claim 12, wherein the system controller is furtherconfigured to: prepare the quantum processor in an initial state bysetting each trapped ion in the quantum processor in the lower energystate of the two frequency-separated states.
 16. The quantum computingsystem according to claim 12, wherein setting the first register of thequantum processor in the superposition of the plurality of string indexstates comprises transferring each trapped ion in the first register ina superposition of the two frequency-separated states.
 17. The quantumcomputing system according to claim 12, wherein circularly shiftingqubits of the second register conditioned on the first registercomprises applying, by the system controller, a combination ofsingle-qubit gate operations and two-qubit gate operations to the firstand second registers of the quantum processor.
 18. The quantum computingsystem according to claim 17, wherein the two-qubit gate operationscomprise controlled-SWAP operations applied to the second registerconditioned on the first register.
 19. The quantum computing systemaccording to claim 17, wherein the two-qubit gate operations comprisecontrolled-SWAP operations applied to the second register conditioned ona plurality of ancillary qubits in which the first register is copied byfan-out CNOT operations applied on the plurality of ancillary qubitsconditioned on the first register.
 20. The quantum computing systemaccording to claim 12, wherein amplifying the state combined with thefirst register in the string index state of the plurality of stringindex states in which the circularly shifted qubits of the secondregister matches qubits of the third register comprises applying, by thesystem controller, a combination of single-qubit gate operations andtwo-qubit gate operations to the second and third registers of thequantum processor.